
namespace FastFood.DataAccess
{
    using System;
    using System.Collections.Generic;
    using System.Data;
    using System.Data.Common;
    using System.Linq;
    using EDOSwit.Entity;
    using FastFood.Business.Entities;
    using FastFood.Business.Entities.Tipos;
    using Microsoft.Practices.EnterpriseLibrary.Data;

	/// <summary>
	/// Represents the DataAccess of MovimientosData.
	/// </summary>
	public class MovimientosData : Singleton<MovimientosData>
	{
		#region Attributes

		private readonly Database BaseDatos = DatabaseFactory.CreateDatabase();

		#endregion

		#region Methods

		/// <summary>
		/// Selects all records from the Movimientos table by a foreign key.
		/// </summary>
		public IList<Movimientos> Listar()
		{
			var entidades = new List<Movimientos>();
			var comando = BaseDatos.GetStoredProcCommand("SelectAllMovimientos");

			using (var lector = BaseDatos.ExecuteReader(comando))
			{
				while (lector.Read())
				{
					entidades.Add(new Movimientos
					{
						movimientoID = lector.IsDBNull(lector.GetOrdinal("movimientoID"))? default(int) : lector.GetInt32(lector.GetOrdinal("movimientoID")),
						loteID = lector.IsDBNull(lector.GetOrdinal("loteID"))? default(int) : lector.GetInt32(lector.GetOrdinal("loteID")),
						almacenID = lector.IsDBNull(lector.GetOrdinal("almacenID"))? default(short) : lector.GetInt16(lector.GetOrdinal("almacenID")),
						cantidad = MathExpression.Round(lector.GetFloat(lector.GetOrdinal("cantidad"))),
						saldo = MathExpression.Round(lector.GetFloat(lector.GetOrdinal("saldo"))),
						motivo = lector.IsDBNull(lector.GetOrdinal("motivo"))? default(byte) : lector.GetByte(lector.GetOrdinal("motivo")),
						operacionID = lector.IsDBNull(lector.GetOrdinal("operacionID"))? default(int) : lector.GetInt32(lector.GetOrdinal("operacionID")),
						personalID = lector.IsDBNull(lector.GetOrdinal("personalID"))? default(short) : lector.GetInt16(lector.GetOrdinal("personalID")),
						fecha = lector.IsDBNull(lector.GetOrdinal("fecha"))? default(DateTime) : lector.GetDateTime(lector.GetOrdinal("fecha"))
					});
				}
			}
			comando.Dispose();
			return entidades;
		}

        public IList<Movimientos> ListarPropios()
        {
            var entidades = new List<Movimientos>();
            var comando = BaseDatos.GetStoredProcCommand("SelectMovimientosPropios");

            using (var lector = BaseDatos.ExecuteReader(comando))
            {
                while (lector.Read())
                {
                    var movimiento = new Movimientos();
                    movimiento.movimientoID = lector.IsDBNull(lector.GetOrdinal("movimientoID")) ? default(int) : lector.GetInt32(lector.GetOrdinal("movimientoID"));
                    movimiento.loteID = lector.IsDBNull(lector.GetOrdinal("loteID")) ? default(int) : lector.GetInt32(lector.GetOrdinal("loteID"));
                    movimiento.almacenID = lector.IsDBNull(lector.GetOrdinal("almacenID")) ? default(short) : lector.GetInt16(lector.GetOrdinal("almacenID"));
                    movimiento.cantidad = MathExpression.Round(Convert.ToSingle(lector.GetValue(lector.GetOrdinal("cantidad"))));
                    movimiento.saldo = MathExpression.Round(Convert.ToSingle(lector.GetValue(lector.GetOrdinal("saldo"))));
                    movimiento.motivo = lector.IsDBNull(lector.GetOrdinal("motivo")) ? default(byte) : lector.GetByte(lector.GetOrdinal("motivo"));
                    movimiento.operacionID = lector.IsDBNull(lector.GetOrdinal("operacionID")) ? default(int) : lector.GetInt32(lector.GetOrdinal("operacionID"));
                    movimiento.personalID = lector.IsDBNull(lector.GetOrdinal("personalID")) ? default(short) : lector.GetInt16(lector.GetOrdinal("personalID"));
                    movimiento.fecha = lector.IsDBNull(lector.GetOrdinal("fecha")) ? default(DateTime) : lector.GetDateTime(lector.GetOrdinal("fecha"));
                    movimiento.insumoID = lector.IsDBNull(lector.GetOrdinal("insumoID")) ? default(short) : lector.GetInt16(lector.GetOrdinal("insumoID"));
                    movimiento.nombreInsumo = lector.IsDBNull(lector.GetOrdinal("insumo")) ? default(string) : lector.GetString(lector.GetOrdinal("insumo"));
                    movimiento.numeroLote = lector.IsDBNull(lector.GetOrdinal("lote")) ? default(string) : lector.GetString(lector.GetOrdinal("lote"));
                    movimiento.nombreAlmacen = lector.IsDBNull(lector.GetOrdinal("almacen")) ? default(string) : lector.GetString(lector.GetOrdinal("almacen"));
                    entidades.Add(movimiento);
                }
            }
            comando.Dispose();
            return entidades;
        }

        public IList<Movimientos> ListarPorMotivo(byte motivo)
        {
            var entidades = new List<Movimientos>();
            var comando = BaseDatos.GetStoredProcCommand("SelectMovimientosByMotivo");

            BaseDatos.AddInParameter(comando, "motivo", DbType.Byte, motivo);

            using (var lector = BaseDatos.ExecuteReader(comando))
            {
                while (lector.Read())
                {
                    var movimiento = new Movimientos();
                    movimiento.movimientoID = lector.IsDBNull(lector.GetOrdinal("movimientoID")) ? default(int) : lector.GetInt32(lector.GetOrdinal("movimientoID"));
                    movimiento.loteID = lector.IsDBNull(lector.GetOrdinal("loteID")) ? default(int) : lector.GetInt32(lector.GetOrdinal("loteID"));
                    movimiento.almacenID = lector.IsDBNull(lector.GetOrdinal("almacenID")) ? default(short) : lector.GetInt16(lector.GetOrdinal("almacenID"));
                    movimiento.cantidad = MathExpression.Round(Convert.ToSingle(lector.GetValue(lector.GetOrdinal("cantidad"))));
                    movimiento.saldo = MathExpression.Round(Convert.ToSingle(lector.GetValue(lector.GetOrdinal("saldo"))));
                    movimiento.motivo = lector.IsDBNull(lector.GetOrdinal("motivo")) ? default(byte) : lector.GetByte(lector.GetOrdinal("motivo"));
                    movimiento.operacionID = lector.IsDBNull(lector.GetOrdinal("operacionID")) ? default(int) : lector.GetInt32(lector.GetOrdinal("operacionID"));
                    movimiento.personalID = lector.IsDBNull(lector.GetOrdinal("personalID")) ? default(short) : lector.GetInt16(lector.GetOrdinal("personalID"));
                    movimiento.fecha = lector.IsDBNull(lector.GetOrdinal("fecha")) ? default(DateTime) : lector.GetDateTime(lector.GetOrdinal("fecha"));
                    movimiento.insumoID = lector.IsDBNull(lector.GetOrdinal("insumoID")) ? default(short) : lector.GetInt16(lector.GetOrdinal("insumoID"));
                    movimiento.nombreInsumo = lector.IsDBNull(lector.GetOrdinal("insumo")) ? default(string) : lector.GetString(lector.GetOrdinal("insumo"));
                    movimiento.numeroLote = lector.IsDBNull(lector.GetOrdinal("lote")) ? default(string) : lector.GetString(lector.GetOrdinal("lote"));
                    movimiento.nombreAlmacen = lector.IsDBNull(lector.GetOrdinal("almacen")) ? default(string) : lector.GetString(lector.GetOrdinal("almacen"));
                    entidades.Add(movimiento);
                }
            }
            comando.Dispose();
            return entidades;
        }

		/// <summary>
		/// Selects all records from the Movimientos table by a foreign key.
		/// </summary>
		public Movimientos Obtener(int movimientoID)
		{
			var movimiento = default(Movimientos);
			var comando = BaseDatos.GetStoredProcCommand("SelectMovimientos");

			BaseDatos.AddInParameter(comando, "movimientoID", DbType.Int32, movimientoID);

			using (var lector = BaseDatos.ExecuteReader(comando))
			{
				while (lector.Read())
				{
			        movimiento = new Movimientos();
                    movimiento.movimientoID = lector.IsDBNull(lector.GetOrdinal("movimientoID")) ? default(int) : lector.GetInt32(lector.GetOrdinal("movimientoID"));
                    movimiento.loteID = lector.IsDBNull(lector.GetOrdinal("loteID")) ? default(int) : lector.GetInt32(lector.GetOrdinal("loteID"));
                    movimiento.almacenID = lector.IsDBNull(lector.GetOrdinal("almacenID")) ? default(short) : lector.GetInt16(lector.GetOrdinal("almacenID"));
                    movimiento.cantidad = MathExpression.Round(Convert.ToSingle(lector.GetValue(lector.GetOrdinal("cantidad"))));
                    movimiento.saldo = MathExpression.Round(Convert.ToSingle(lector.GetValue(lector.GetOrdinal("saldo"))));
                    movimiento.motivo = lector.IsDBNull(lector.GetOrdinal("motivo")) ? default(byte) : lector.GetByte(lector.GetOrdinal("motivo"));
                    movimiento.operacionID = lector.IsDBNull(lector.GetOrdinal("operacionID")) ? default(int) : lector.GetInt32(lector.GetOrdinal("operacionID"));
                    movimiento.personalID = lector.IsDBNull(lector.GetOrdinal("personalID")) ? default(short) : lector.GetInt16(lector.GetOrdinal("personalID"));
                    movimiento.fecha = lector.IsDBNull(lector.GetOrdinal("fecha")) ? default(DateTime) : lector.GetDateTime(lector.GetOrdinal("fecha"));
                    movimiento.insumoID = lector.IsDBNull(lector.GetOrdinal("insumoID")) ? default(short) : lector.GetInt16(lector.GetOrdinal("insumoID"));
				}
			}
			comando.Dispose();
			return movimiento;
		}

        /// <summary>
        /// Saves a record to the Movimientos table.
        /// </summary>
        public int Agregar(Movimientos movimiento)
        {
            var movimientoID = 0;
            using (DbConnection conexion = BaseDatos.CreateConnection())
            {
                conexion.Open();
                DbTransaction transaccion = conexion.BeginTransaction();

                try
                {
                    var motivoMovimiento = (MotivoMovimiento)Enum.Parse(typeof(MotivoMovimiento), movimiento.motivo.ToString());
                    switch (motivoMovimiento)
                    {
                        case MotivoMovimiento.Ventas:
                        case MotivoMovimiento.Cocina:
                        case MotivoMovimiento.ControlCalidad:
                        case MotivoMovimiento.Expiracion:
                        case MotivoMovimiento.SalidaPorAjuste:
                            movimiento.cantidad = -1 * movimiento.cantidad;
                            break;
                        case MotivoMovimiento.Compras:
                        case MotivoMovimiento.IngresoPorAjuste:
                            movimiento.cantidad = movimiento.cantidad;
                            break;
                        default:
                            break;
                    }

                    double stock = 0;
                    var comandoAlmacenamiento = BaseDatos.GetStoredProcCommand("SelectAlmacenamientos");
                    BaseDatos.AddInParameter(comandoAlmacenamiento, "loteID", DbType.Int32, movimiento.loteID);
                    BaseDatos.AddInParameter(comandoAlmacenamiento, "almacenID", DbType.Int16, movimiento.almacenID);

                    using (var lector = BaseDatos.ExecuteReader(comandoAlmacenamiento, transaccion))
                    {
                        if (lector.Read())
                        {
                            stock = MathExpression.Round(lector.GetDouble(lector.GetOrdinal("stock")));
                        }
                    }
                    comandoAlmacenamiento.Dispose();
                    movimiento.cantidad = MathExpression.Round(movimiento.cantidad);
                    movimiento.saldo = MathExpression.Round(stock + movimiento.cantidad);

                    var movimientos = new List<Movimientos>();
                    var comando = BaseDatos.GetStoredProcCommand("SelectMovimientosByMotivo");
                    BaseDatos.AddInParameter(comando, "motivo", DbType.Byte, movimiento.motivo);

                    using (var lector = BaseDatos.ExecuteReader(comando, transaccion))
                    {
                        while (lector.Read())
                        {
                           movimientos.Add(new Movimientos
                           {
                               movimientoID = lector.GetInt32(lector.GetOrdinal("movimientoID")),
                               operacionID = lector.GetInt32(lector.GetOrdinal("operacionID"))
                           });
                        }
                    }
                    comando.Dispose();
                    var ultimoMovimiento = movimientos.OrderBy(p => p.operacionID).LastOrDefault();

                    var operacionID = ultimoMovimiento == null ? 1 : ultimoMovimiento.operacionID + 1;
                    movimiento.operacionID = operacionID;

                    movimientoID = AgregarConFecha(movimiento, transaccion);
                    AlmacenamientosData.Instancia.ModificarStock(movimiento.loteID, movimiento.almacenID, movimiento.cantidad, transaccion);
                    LotesData.Instancia.ModificarStock(movimiento.loteID, movimiento.cantidad, transaccion);
                    InsumosData.Instancia.ModificarStock(movimiento.insumoID, movimiento.cantidad, transaccion);

                    transaccion.Commit();
                }
                catch (Exception ex)
                {
                    transaccion.Rollback();
                    throw new Exception(ex.Message);
                }
                conexion.Close();
            }
            return movimientoID;
        }

		/// <summary>
		/// Saves a record to the Movimientos table.
		/// </summary>
		public int Agregar(Movimientos movimientos, DbTransaction transaccion)
		{
			var comando = BaseDatos.GetStoredProcCommand("InsertMovimientos");
			BaseDatos.AddOutParameter(comando, "movimientoID", DbType.Int32, 4);
			BaseDatos.AddInParameter(comando, "loteID", DbType.Int32, movimientos.loteID);
			BaseDatos.AddInParameter(comando, "almacenID", DbType.Int16, movimientos.almacenID);
			BaseDatos.AddInParameter(comando, "cantidad", DbType.Single, MathExpression.Round(movimientos.cantidad));
            BaseDatos.AddInParameter(comando, "saldo", DbType.Single, MathExpression.Round(movimientos.saldo));
			BaseDatos.AddInParameter(comando, "motivo", DbType.Byte, movimientos.motivo);
			BaseDatos.AddInParameter(comando, "operacionID", DbType.Int32, movimientos.operacionID);
			BaseDatos.AddInParameter(comando, "personalID", DbType.Int16, movimientos.personalID);

            var resultado = BaseDatos.ExecuteNonQuery(comando, transaccion);
			if (resultado == 0) throw new Exception("Error al Agregar Movimientos.");

			var valorDevuelto = (int)BaseDatos.GetParameterValue(comando, "movimientoID");;
			comando.Dispose();
			return valorDevuelto;
		}

        public int AgregarConFecha(Movimientos movimientos, DbTransaction transaccion)
        {
            var comando = BaseDatos.GetStoredProcCommand("InsertMovimientosConFecha");
            BaseDatos.AddOutParameter(comando, "movimientoID", DbType.Int32, 4);
            BaseDatos.AddInParameter(comando, "loteID", DbType.Int32, movimientos.loteID);
            BaseDatos.AddInParameter(comando, "almacenID", DbType.Int16, movimientos.almacenID);
            BaseDatos.AddInParameter(comando, "cantidad", DbType.Single, MathExpression.Round(movimientos.cantidad));
            BaseDatos.AddInParameter(comando, "saldo", DbType.Single, MathExpression.Round(movimientos.saldo));
            BaseDatos.AddInParameter(comando, "motivo", DbType.Byte, movimientos.motivo);
            BaseDatos.AddInParameter(comando, "operacionID", DbType.Int32, movimientos.operacionID);
            BaseDatos.AddInParameter(comando, "personalID", DbType.Int16, movimientos.personalID);
            BaseDatos.AddInParameter(comando, "fecha", DbType.DateTime, movimientos.fecha);

            var resultado = BaseDatos.ExecuteNonQuery(comando, transaccion);
            if (resultado == 0) throw new Exception("Error al Agregar Movimientos.");

            var valorDevuelto = (int)BaseDatos.GetParameterValue(comando, "movimientoID"); ;
            comando.Dispose();
            return valorDevuelto;
        }

		/// <summary>
		/// Updates a record in the Movimientos table.
		/// </summary>
        public bool Modificar(Movimientos movimiento)
        {
            using (DbConnection conexion = BaseDatos.CreateConnection())
            {
                conexion.Open();
                DbTransaction transaccion = conexion.BeginTransaction();

                try
                {
                    #region Retornar la cantidad movida

                    var movimientantiguo = Obtener(movimiento.movimientoID);
                    movimientantiguo.cantidad = -1 * movimientantiguo.cantidad;

                    AlmacenamientosData.Instancia.ModificarStock(movimientantiguo.loteID, movimientantiguo.almacenID, movimientantiguo.cantidad, transaccion);
                    LotesData.Instancia.ModificarStock(movimientantiguo.loteID, movimientantiguo.cantidad, transaccion);
                    InsumosData.Instancia.ModificarStock(movimientantiguo.insumoID, movimientantiguo.cantidad, transaccion);

                    #endregion

                    #region Registrar la nueva cantidad movida

                    var motivoMovimiento = (MotivoMovimiento)Enum.Parse(typeof(MotivoMovimiento), movimiento.motivo.ToString());
                    switch (motivoMovimiento)
                    {
                        case MotivoMovimiento.Ventas:
                        case MotivoMovimiento.Cocina:
                        case MotivoMovimiento.ControlCalidad:
                        case MotivoMovimiento.Expiracion:
                        case MotivoMovimiento.SalidaPorAjuste:
                            movimiento.cantidad = -1 * movimiento.cantidad;
                            break;
                        case MotivoMovimiento.Compras:
                        case MotivoMovimiento.IngresoPorAjuste:
                            movimiento.cantidad = movimiento.cantidad;
                            break;
                        default:
                            break;
                    }

                    double stock = 0;
                    var comandoAlmacenamiento = BaseDatos.GetStoredProcCommand("SelectAlmacenamientos");
                    BaseDatos.AddInParameter(comandoAlmacenamiento, "loteID", DbType.Int32, movimiento.loteID);
                    BaseDatos.AddInParameter(comandoAlmacenamiento, "almacenID", DbType.Int16, movimiento.almacenID);

                    using (var lector = BaseDatos.ExecuteReader(comandoAlmacenamiento, transaccion))
                    {
                        if (lector.Read())
                        {
                            stock = MathExpression.Round(lector.GetDouble(lector.GetOrdinal("stock")));
                        }
                    }
                    comandoAlmacenamiento.Dispose();
                    movimiento.cantidad = MathExpression.Round(movimiento.cantidad);
                    movimiento.saldo = MathExpression.Round(stock + movimiento.cantidad);
                    movimiento.operacionID = movimientantiguo.operacionID;

                    var comando = BaseDatos.GetStoredProcCommand("UpdateMovimientos");
                    BaseDatos.AddInParameter(comando, "movimientoID", DbType.Int32, movimiento.movimientoID);
                    BaseDatos.AddInParameter(comando, "loteID", DbType.Int32, movimiento.loteID);
                    BaseDatos.AddInParameter(comando, "almacenID", DbType.Int16, movimiento.almacenID);
                    BaseDatos.AddInParameter(comando, "cantidad", DbType.Single, movimiento.cantidad);
                    BaseDatos.AddInParameter(comando, "saldo", DbType.Single, movimiento.saldo);
                    BaseDatos.AddInParameter(comando, "motivo", DbType.Byte, movimiento.motivo);
                    BaseDatos.AddInParameter(comando, "operacionID", DbType.Int32, movimiento.operacionID);
                    BaseDatos.AddInParameter(comando, "personalID", DbType.Int16, movimiento.personalID);
                    BaseDatos.AddInParameter(comando, "fecha", DbType.DateTime, movimiento.fecha);

                    var resultado = BaseDatos.ExecuteNonQuery(comando, transaccion);
                    if (resultado == 0) throw new Exception("Error al Modificar Movimientos.");

                    AlmacenamientosData.Instancia.ModificarStock(movimiento.loteID, movimiento.almacenID, movimiento.cantidad, transaccion);
                    LotesData.Instancia.ModificarStock(movimiento.loteID, movimiento.cantidad, transaccion);
                    InsumosData.Instancia.ModificarStock(movimiento.insumoID, movimiento.cantidad, transaccion);

                    #endregion

                    transaccion.Commit();
                }
                catch (Exception ex)
                {
                    transaccion.Rollback();
                    throw new Exception(ex.Message);
                }
                conexion.Close();
            }
            return true;
        }

		/// <summary>
		/// Deletes a record from the Movimientos table by its primary key.
		/// </summary>
        public bool Eliminar(Movimientos movimiento)
        {
            using (DbConnection conexion = BaseDatos.CreateConnection())
            {
                conexion.Open();
                DbTransaction transaccion = conexion.BeginTransaction();

                try
                {
                    var movimientantiguo = Obtener(movimiento.movimientoID);
                    movimientantiguo.cantidad = -1 * movimientantiguo.cantidad;

                    AlmacenamientosData.Instancia.ModificarStock(movimientantiguo.loteID, movimientantiguo.almacenID, movimientantiguo.cantidad, transaccion);
                    LotesData.Instancia.ModificarStock(movimientantiguo.loteID, movimientantiguo.cantidad, transaccion);
                    InsumosData.Instancia.ModificarStock(movimientantiguo.insumoID, movimientantiguo.cantidad, transaccion);

                    var comando = BaseDatos.GetStoredProcCommand("DeleteMovimientos");
                    BaseDatos.AddInParameter(comando, "movimientoID", DbType.Int32, movimiento.movimientoID);

                    var resultado = BaseDatos.ExecuteNonQuery(comando);
                    if (resultado == 0) throw new Exception("Error al Eliminar Movimientos.");

                    transaccion.Commit();
                }
                catch (Exception ex)
                {
                    transaccion.Rollback();
                    throw new Exception(ex.Message);
                }
                conexion.Close();
            }
            return true;
        }

		/// <summary>
		/// Selects all records from the Movimientos table by a foreign key.
		/// </summary>
		public IList<Movimientos> ListarPorAlmacenID(short almacenID)
		{
			var entidades = new List<Movimientos>();
			var comando = BaseDatos.GetStoredProcCommand("SelectMovimientosByAlmacenID");

			BaseDatos.AddInParameter(comando, "almacenID", DbType.Int16, almacenID);

			using (var lector = BaseDatos.ExecuteReader(comando))
			{
				while (lector.Read())
				{
					entidades.Add(new Movimientos
					{
						movimientoID = lector.IsDBNull(lector.GetOrdinal("movimientoID"))? default(int) : lector.GetInt32(lector.GetOrdinal("movimientoID")),
						loteID = lector.IsDBNull(lector.GetOrdinal("loteID"))? default(int) : lector.GetInt32(lector.GetOrdinal("loteID")),
						almacenID = lector.IsDBNull(lector.GetOrdinal("almacenID"))? default(short) : lector.GetInt16(lector.GetOrdinal("almacenID")),
						cantidad = MathExpression.Round(Convert.ToSingle(lector.GetValue(lector.GetOrdinal("cantidad")))),
                        saldo = MathExpression.Round(Convert.ToSingle(lector.GetValue(lector.GetOrdinal("saldo")))),
						motivo = lector.IsDBNull(lector.GetOrdinal("motivo"))? default(byte) : lector.GetByte(lector.GetOrdinal("motivo")),
						operacionID = lector.IsDBNull(lector.GetOrdinal("operacionID"))? default(int) : lector.GetInt32(lector.GetOrdinal("operacionID")),
						personalID = lector.IsDBNull(lector.GetOrdinal("personalID"))? default(short) : lector.GetInt16(lector.GetOrdinal("personalID")),
						fecha = lector.IsDBNull(lector.GetOrdinal("fecha"))? default(DateTime) : lector.GetDateTime(lector.GetOrdinal("fecha"))
					});
				}
			}
			comando.Dispose();
			return entidades;
		}

		/// <summary>
		/// Selects all records from the Movimientos table by a foreign key.
		/// </summary>
		public IList<Movimientos> ListarPorLoteID(int loteID)
		{
			var entidades = new List<Movimientos>();
			var comando = BaseDatos.GetStoredProcCommand("SelectMovimientosByLoteID");

			BaseDatos.AddInParameter(comando, "loteID", DbType.Int32, loteID);

			using (var lector = BaseDatos.ExecuteReader(comando))
			{
				while (lector.Read())
				{
					entidades.Add(new Movimientos
					{
						movimientoID = lector.IsDBNull(lector.GetOrdinal("movimientoID"))? default(int) : lector.GetInt32(lector.GetOrdinal("movimientoID")),
						loteID = lector.IsDBNull(lector.GetOrdinal("loteID"))? default(int) : lector.GetInt32(lector.GetOrdinal("loteID")),
						almacenID = lector.IsDBNull(lector.GetOrdinal("almacenID"))? default(short) : lector.GetInt16(lector.GetOrdinal("almacenID")),
                        cantidad = MathExpression.Round(Convert.ToSingle(lector.GetValue(lector.GetOrdinal("cantidad")))),
                        saldo = MathExpression.Round(Convert.ToSingle(lector.GetValue(lector.GetOrdinal("saldo")))),
						motivo = lector.IsDBNull(lector.GetOrdinal("motivo"))? default(byte) : lector.GetByte(lector.GetOrdinal("motivo")),
						operacionID = lector.IsDBNull(lector.GetOrdinal("operacionID"))? default(int) : lector.GetInt32(lector.GetOrdinal("operacionID")),
						personalID = lector.IsDBNull(lector.GetOrdinal("personalID"))? default(short) : lector.GetInt16(lector.GetOrdinal("personalID")),
						fecha = lector.IsDBNull(lector.GetOrdinal("fecha"))? default(DateTime) : lector.GetDateTime(lector.GetOrdinal("fecha"))
					});
				}
			}
			comando.Dispose();
			return entidades;
		}

		/// <summary>
		/// Selects all records from the Movimientos table by a foreign key.
		/// </summary>
		public IList<Movimientos> ListarPorPersonalID(short personalID)
		{
			var entidades = new List<Movimientos>();
			var comando = BaseDatos.GetStoredProcCommand("SelectMovimientosByPersonalID");

			BaseDatos.AddInParameter(comando, "personalID", DbType.Int16, personalID);

			using (var lector = BaseDatos.ExecuteReader(comando))
			{
				while (lector.Read())
				{
					entidades.Add(new Movimientos
					{
						movimientoID = lector.IsDBNull(lector.GetOrdinal("movimientoID"))? default(int) : lector.GetInt32(lector.GetOrdinal("movimientoID")),
						loteID = lector.IsDBNull(lector.GetOrdinal("loteID"))? default(int) : lector.GetInt32(lector.GetOrdinal("loteID")),
						almacenID = lector.IsDBNull(lector.GetOrdinal("almacenID"))? default(short) : lector.GetInt16(lector.GetOrdinal("almacenID")),
                        cantidad = MathExpression.Round(Convert.ToSingle(lector.GetValue(lector.GetOrdinal("cantidad")))),
                        saldo = MathExpression.Round(Convert.ToSingle(lector.GetValue(lector.GetOrdinal("saldo")))),
						motivo = lector.IsDBNull(lector.GetOrdinal("motivo"))? default(byte) : lector.GetByte(lector.GetOrdinal("motivo")),
						operacionID = lector.IsDBNull(lector.GetOrdinal("operacionID"))? default(int) : lector.GetInt32(lector.GetOrdinal("operacionID")),
						personalID = lector.IsDBNull(lector.GetOrdinal("personalID"))? default(short) : lector.GetInt16(lector.GetOrdinal("personalID")),
						fecha = lector.IsDBNull(lector.GetOrdinal("fecha"))? default(DateTime) : lector.GetDateTime(lector.GetOrdinal("fecha"))
					});
				}
			}
			comando.Dispose();
			return entidades;
		}

        public IList<Movimientos> ListarPorOperacionID(int operacionID)
        {
            var entidades = new List<Movimientos>();
            var comando = BaseDatos.GetStoredProcCommand("SelectMovimientosByOperacionID");

            BaseDatos.AddInParameter(comando, "operacionID", DbType.Int32, operacionID);

            using (var lector = BaseDatos.ExecuteReader(comando))
            {
                while (lector.Read())
                {
                    var movimiento = new Movimientos();
                    movimiento.movimientoID = lector.IsDBNull(lector.GetOrdinal("movimientoID")) ? default(int) : lector.GetInt32(lector.GetOrdinal("movimientoID"));
                    movimiento.loteID = lector.IsDBNull(lector.GetOrdinal("loteID")) ? default(int) : lector.GetInt32(lector.GetOrdinal("loteID"));
                    movimiento.almacenID = lector.IsDBNull(lector.GetOrdinal("almacenID")) ? default(short) : lector.GetInt16(lector.GetOrdinal("almacenID"));
                    movimiento.cantidad = MathExpression.Round(Convert.ToSingle(lector.GetValue(lector.GetOrdinal("cantidad"))));
                    movimiento.saldo = MathExpression.Round(Convert.ToSingle(lector.GetValue(lector.GetOrdinal("saldo"))));
                    movimiento.motivo = lector.IsDBNull(lector.GetOrdinal("motivo")) ? default(byte) : lector.GetByte(lector.GetOrdinal("motivo"));
                    movimiento.operacionID = lector.IsDBNull(lector.GetOrdinal("operacionID")) ? default(int) : lector.GetInt32(lector.GetOrdinal("operacionID"));
                    movimiento.personalID = lector.IsDBNull(lector.GetOrdinal("personalID")) ? default(short) : lector.GetInt16(lector.GetOrdinal("personalID"));
                    movimiento.fecha = lector.IsDBNull(lector.GetOrdinal("fecha")) ? default(DateTime) : lector.GetDateTime(lector.GetOrdinal("fecha"));
                    movimiento.insumoID = lector.IsDBNull(lector.GetOrdinal("insumoID")) ? default(short) : lector.GetInt16(lector.GetOrdinal("insumoID"));
                    entidades.Add(movimiento);
                }
            }
            comando.Dispose();
            return entidades;
        }

		#endregion
	}
}
